/**
 * Created by xiebang
 * Description
 * User:小谢
 * Date:2021-08-02
 * Time:10:42
 */
class Person {
    public static int  count = 0;//静态的成员变量储存在方法区
    //属性  成员变量：定义在类中方法外的变量
//    public int age ;
//    public String name;//字段是public不安全
    private int age ;
    private String name;//字段是public不安全
//    {
//        //初始化一些实例数据成员
//        this.name = "bit";
//        this.age = 19;
//        System.out.println("实例代码块");
//    }
//    static {
//        //初始化静态的数据成员和需要提前准备的一些数据
//        System.out.println("静态代码块");
//    }
//    public void setName(String myname){
//        name = myname;
//    }
//    public String getName() {
//        return name;
//    }
//    public boolean flg;
//    public char ch;
    //行为 ：成员方法
    public void eat() {
        System.out.println(name + "吃饭");
    }
    //静态的方法
    public static void func() {
       // eat();//不说静态方法不能调用。 eat是普通方法    普通方法是通过（需要对象）  对象的引用.方法名调用 （不需要对象）静态方法 通过 类型.方法名调用。
        System.out.println("这是一个静态的成员方法");
    }
    public static final int SIZE = 10;//静态常量也在方法区  与fianl无关
    @Override//重写的注解 重写的object的方法
    public String toString() {
        return "Person{" +
                "年龄=" + age +
                ", 姓名='" + name + '\'' +
                '}';
    }
    public void show() {
        eat();
        func();
        System.out.println("姓名" + name +" 年龄" + age);
        //System.out.println(flg + " " + ch);//ch默认什么都没有
    }

    //get 和 set方法
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        //this 代表当前对象的一个引用
        this.name = name;//局部变量优先使用
    }

    public Person() {
      //  this调用其他构造方法
        this("谢邦",19);//this调用构造方法一定要放在第一行。
        System.out.println("不带参数的构造方法");
}
    public Person(String name) {
        this.name = name;
        System.out.println("带一个参数的构造方法");
}

public Person(String name,int age) {
        this.name = name;
        this.age = age;
    System.out.println("带两个参数的构造方法");
}


}
class Test {
    public int a;
    public static int count;
        }
public class TestDemo {
    //匿名对象
    public static void main10(String[] args) {
       Person person =new Person();
       person.eat();;
        System.out.println(person.getName());
        //匿名对象只适合使用一次的场景
        //只要你再次使用都要new对象
        new Person().eat();
        System.out.println(new Person().getName());
    }

    //序列化：将对象转化为字符串
    //
    //代码块
    //静态代码块先执行,但是对于同一个类来说，静态代码块只执行一次
    //然后是实例代码块
    //然后才是构造方法
    public static void main9(String[] args) {
        Person person = new Person();
        System.out.println("=====================");
        //
        Person person1 = new Person();
    }
    //构造方法：方法名与类名相同的方法没没有返回值
    //实例化对象 需要两步
    //1.分配内存
    //2.调用构造方法（
    //前提是当前类中没有提供任何构造方法，编译器提供一个默认不带参数的构建方法
    //不仅仅构造对象，还蹦对成员变量进行初始化
    public static void main(String[] args) {
        Person person = new Person();//说明 this不是代表当前对象，而是当前对象的引用
        //this。成员变量
        //this.方法名
        //this调用其他构造方法
        //静态方法不能出现this
        //
        Person person1 = new Person("BIT");
        Person person2 = new Person("BIT",12);
    }
    //万一改变了属性的名字 ,程序就会报错, 所以需要封装
    //怎么封装？属性或方法用private来修饰
    //public 和 private是访问修饰限定符
    public static void main7(String[] args) {
        Person person = new Person();
        person.setName("bit");
        System.out.println(person.getName());
//        person.name = "bit";
//        person.age = 19;
    }

    public void func2() {

    }
    //为什么main函数是静态的？
    //因为非静态的函数需要实例化才能被调用
    public void main6(String[] args) {
            TestDemo testDemo = new TestDemo();
            testDemo.func2();
    }
    //成员变量才会在对象内在堆区，静态的成员变量在方法1区。，并且只有一个
    public static void main5(String[] args) {
        Test t1 = new Test();
        t1.a++;
        Test.count++;
        System.out.println(t1.a);
        System.out.println(Test.count);
        System.out.println("==================");
        Test t2 = new Test();
        t2.a++;
        Test.count++;
        System.out.println(t2.a);
        System.out.println(Test.count);
    }
    public static void main4(String[] args) {
        //静态的成员变量是通过类名.变量名去访问的 //不需要示例化对象
        System.out.println(Person.count);
        Person.func();
    }
    public static void main3(String[] args) {
        Person person = new Person();
        System.out.println(person);
        //System.out.println(person.name.length());//NullPointerException
        //Person person = null;//空指针异常
/*        System.out.println(person.name);
        person.show();
        person.name = " bit";*/

    }
    public static void main2(String[] args) {
        //
        //构建对象 1分配内存 2.调用时候的构造方法。
        //person是引用变量  person在栈上， 对象产生在堆上成员变量
        Person person = new Person(); //前提是，当前类中不提供构造方法。编译器会提供一个默认的构造方法
        Person person1 = new Person();
/*        Person person1 = new Person("bit");//不仅仅能构造对象，还能对象进行初始化
        System.out.println(person1.getName());
        Person person2 = new Person("bit",12);//this 代表当前对象的引用
        System.out.println(person2.getName());
        System.out.println(person2.getAge());*/
//        person.age = 90;
//        person.name = "bit"; //普通成员变量通过对象.变量名访问
//        person.eat();
//        person.toString();
//        System.out.println("-----------------------");
//        person1.age = 18;
//        person1.name = "bit2"; //普通成员变量通过对象.变量名访问
//        person1.toString();
//        person1.toString();
/*        person.setName( "谢超帮");
        String name = person.getName();
        System.out.println(name);*/
    }
    public static void main1(String[] args) {
        Person person = new Person();
        //person.setName( "谢超帮");
        //String name = person.getName();
        //System.out.println(name);
        //count不属于对象属于类
       // System.out.println(Person.count);
    }
}
